home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d16 / winvn060.arc / WVSOCK.C < prev    next >
C/C++ Source or Header  |  1991-07-01  |  16KB  |  587 lines
  1. /*--  First line of WVSock.c ------------------------------------ */
  2. #define _NEAR
  3. #define _CDECL
  4. #undef LINT_ARGS
  5.  
  6. #include "windows.h"
  7. #include "wvglob.h"
  8. #include "winvn.h"
  9. #ifndef MAC
  10. #include <pctcp/types.h>
  11. #include <pctcp/pctcp.h>
  12. #include <pctcp/sockets.h>
  13. #include <pctcp/options.h>
  14. #include <pctcp/error.h>
  15. #else
  16. #include <SerialDvr.h>
  17. #include <MacTCPCommonTypes.h>
  18. #include <AddressXlation.h>
  19. #include <TCPPB.h>
  20. #endif
  21. #ifndef MAC
  22. #include <memory.h>
  23. #include <dos.h>
  24.  
  25. #ifdef NET_FAR
  26. extern int far net_connect(int nd, int type, struct addr far *addr);
  27. extern int far net_read(int nd, char far *buf, unsigned len, struct addr far *from, unsigned flags);
  28. extern int far net_write(int nd, char far *buf, unsigned len, unsigned flags);
  29. extern int far net_release(int nd);
  30. extern long far inet_addr(char far *cp);
  31. #else
  32. long inet_addr(char *cp);
  33. #endif
  34. #endif
  35.  
  36. union {
  37.    struct {
  38.       unsigned int toff;
  39.       unsigned int tseg;
  40.    } structaddr;
  41.    char far * far * TCPpos;
  42. } TCPaddr;
  43.  
  44. #ifdef MAC
  45. void ClearParamBlock(char *paramBlock,int  nbytes);
  46. #endif
  47.  
  48. #ifdef MAC
  49. #define COMMBUFSIZE   1600
  50. #define TCPBUFSIZE   16384
  51. #else
  52. #define COMMBUFSIZE  1600
  53. #endif
  54. #define USE_NET 1
  55. #define SERIALOUTBUFSIZE  1024
  56.  
  57. #ifdef TSRBUF
  58. char far *CommBuff;
  59. #define INTBUFPTR (0x85*4)
  60. #else
  61. char CommBuff[COMMBUFSIZE];
  62. #endif
  63. int  CommBuffIdx=COMMBUFSIZE+1;
  64. int  CharsInCommBuff=0;
  65. int  CharsInSkLine=70;
  66. #define DEBUGSIZE 200
  67. char DebugKeyBuf[DEBUGSIZE];
  68. int  DebugKeyIdx=0;
  69.  
  70. #ifndef MAC
  71. struct addr a;
  72. struct addr from;
  73. int NNTPSock;
  74. int DebugSock = 0;
  75. char mymesbuf[80];
  76.  
  77. union REGS inregs, outregs;
  78. struct SREGS segregs;
  79. #else
  80. StreamPtr NNTPSock;
  81. rdsEntry myRDS[2];
  82. wdsEntry myWDS[2];
  83. BOOL prevTCPError = FALSE;
  84. #endif
  85.  
  86. #ifdef MAC
  87. int serialIn = AinRefNum;
  88. int serialOut = AoutRefNum;
  89. int whichPort = sPortA;
  90. int serConfig = stop10+evenParity+data7+baud9600;
  91. Handle hSerBuf;
  92. char *lpSerBuf;
  93. Size SerBufSize = COMMBUFSIZE+2;
  94. OSErr myOSErr;
  95.  
  96. short int SockRefNum;
  97. TCPiopb TCPparamBlock;
  98. TCPiopb TCPReadparamBlock;
  99. #endif
  100.  
  101. /*-- function SetupSock --------------------------------------------
  102.  *
  103.  *   Setups up BSD-style socket to the NNTP server.
  104.  *
  105.  *   Returns 1 upon success, else 0.
  106.  */
  107. int
  108. SetupSock()
  109. {
  110.    int protocol = 0;
  111.    int nntpport = 119;
  112.    int j;
  113.    int result;
  114.    char mes[100];
  115.    char buf[60];
  116.    long destaddr;
  117. #ifndef MAC
  118.    destaddr = inet_addr(NNTPIPAddr);
  119.  
  120.    /* Set up name structure */
  121.  
  122.    memcpy(&a.fhost,&destaddr,sizeof(a.fhost));
  123.    a.lsocket = 0;
  124.    a.fsocket = NNTPPort;
  125.    a.protocol = 0;
  126.  
  127.    LockData(0);
  128.    if(DebugSock) {
  129.         MessageBox(hWndConf,"Ready to call net_connect","in SetupSock",MB_OK);
  130.    }
  131. #ifdef USE_NET
  132.    NNTPSock = net_connect(-1,STREAM,&a);
  133. #else
  134.    inregs.h.ah = 0x13;  /* net_connect */
  135.    inregs.x.bx = 0xffff;  /* nd = -1 */
  136.    segregs.ds =  HIWORD((char far *)(&a));
  137.    inregs.x.si = LOWORD((char far *)(&a));
  138.    inregs.x.dx = STREAM;
  139.  
  140.    NNTPSock = int86x(0x61,&inregs,&outregs,&segregs);
  141.  
  142. #endif
  143.    if(DebugSock || NNTPSock == -1) {
  144.       sprintf(mes,"net_connect returned %d; neterrno=%d",NNTPSock,neterrno);
  145.       MessageBox(hWndConf,mes,"Error from 'net_connect'",MB_OK|MB_ICONHAND);
  146. #if 0
  147.       return(0);
  148. #endif
  149.    }
  150. #endif
  151.    return(1);
  152. }
  153.  
  154. /*-- function MRRReadComm ---------------------------------------
  155.  *
  156.  *  Reads characters from either a serial line or TCP socket.
  157.  */
  158. int
  159. MRRReadComm()
  160. {
  161.    int bytesread, ch;
  162.    int myerr;
  163.    long int lCount;
  164.    char mesbuf[80];
  165. #ifdef MAC
  166.    static BOOL waiting=TRUE;
  167.    BOOL doread=FALSE;
  168. #endif
  169.  
  170.    if(CommBuffIdx < CharsInCommBuff) {
  171.    } else if(UsingSocket) {
  172. #ifndef MAC
  173. #ifdef USE_NET
  174. #if 0
  175.       MessageBox(hWndConf,"About to net_read","in MRRReadComm",MB_OK);
  176. #endif
  177.       bytesread = net_read(NNTPSock,CommBuff,COMMBUFSIZE,&from,NET_FLG_NONBLOCKING);
  178. #if 0
  179.       MessageBox(hWndConf,"Just did net_read","in MRRReadComm",MB_OK);
  180. #endif
  181. #else
  182.       inregs.h.ah = 0x1b;
  183.       inregs.x.bx = NNTPSock;
  184.       segregs.ds  = HIWORD((char far *)CommBuff);
  185.       inregs.x.si = LOWORD((char far *)CommBuff);
  186.       inregs.x.cx = COMMBUFSIZE;
  187.       segregs.es =  HIWORD((char far *)(NULL));
  188.       inregs.x.di = LOWORD((char far *)(NULL));
  189.       inregs.x.dx = NET_FLG_NONBLOCKING;
  190.  
  191. #if 1
  192.       myerr = int86x(0x61,&inregs,&outregs,&segregs);
  193. #else
  194.       outregs.x.cflag = 1;
  195.       myerr = NET_ERR_WOULD_BLOCK;
  196. #endif
  197.       if(outregs.x.cflag) {
  198.          bytesread = -1;
  199.       } else {
  200.          bytesread = outregs.x.cx;
  201.       }
  202.       neterrno = myerr & 0xff;
  203. #endif
  204.    /* ifdef USE_NET */
  205.       if(!bytesread || (bytesread == (-1) && neterrno==NET_ERR_WOULD_BLOCK)) {
  206.          return(-1);
  207.       } else if(bytesread > 0) {
  208.      if(DebugSock) {
  209.         sprintf(mymesbuf,"bytesread=%d '%.30s'",bytesread,CommBuff);
  210.         MessageBox(hWndConf,mymesbuf,"Read bytes in MRRReadComm",MB_OK);
  211.      }
  212.          CharsInCommBuff = bytesread;
  213.          CommBuffIdx = 0;
  214.       } else {
  215.          sprintf(mymesbuf,"NNTPSock=%d  bytesread=%d  neterrno=%d",NNTPSock,bytesread,neterrno);
  216.          MessageBox(hWndConf,mymesbuf,"in MRRReadComm, probs",MB_OK|MB_ICONHAND);
  217.          return(-1);
  218.       }
  219. #else
  220.   /* ifndef MAC */
  221.       /* Mac code to read from socket. */
  222.  
  223.       if(TCPReadparamBlock.ioResult == inProgress) {
  224.          return(-1);
  225.       } else if(TCPReadparamBlock.ioResult == commandTimeout) {
  226.          doread = TRUE;
  227.          TCPReadparamBlock.ioResult = 0;
  228.       } else if(TCPReadparamBlock.ioResult < 0 && !prevTCPError) {
  229.          sprintf(mesbuf,"TCPRcv returned ioResult = %d",TCPReadparamBlock.ioResult);
  230.          MessageBox(hWndConf,mesbuf,"Serious Communication error",MB_OK|MB_ICONHAND);
  231.          prevTCPError = TRUE;
  232.       } else if(waiting) {
  233.          bytesread = TCPReadparamBlock.csParam.receive.rcvBuffLen;
  234.          CharsInCommBuff = bytesread;
  235.          CommBuffIdx = 0;
  236.          waiting = FALSE;
  237.       } else {
  238.          waiting = TRUE;
  239.          doread = TRUE;
  240.       }
  241.       if(doread) {
  242.          TCPReadparamBlock.csCode = TCPRcv;
  243. /*       TCPReadparamBlock.csParam.receive.commandTimeoutValue = 1; */
  244.          TCPReadparamBlock.csParam.receive.rcvBuff = CommBuff;
  245.          TCPReadparamBlock.csParam.receive.rcvBuffLen = COMMBUFSIZE;
  246.             myOSErr = PBControl(&TCPReadparamBlock,TRUE);
  247.          if(myOSErr != noErr &&  myOSErr != commandTimeout) {
  248.             sprintf(mesbuf,"TCPRcv ret %d, bytes=%d mes='%.45s'",myOSErr,bytesread,CommBuff);
  249.             MessageBox(hWndConf,mesbuf,"",MB_OK|MB_ICONHAND);
  250.          }
  251.          return(-1);
  252.       }
  253. #endif
  254.    } else {
  255. #ifndef MAC
  256.       bytesread = ReadComm(CommDevice,CommBuff,COMMBUFSIZE);
  257. #else
  258.       SerGetBuf(serialIn,&lCount);
  259.       FSRead(serialIn,&lCount,CommBuff);
  260.       bytesread = lCount;
  261. #endif
  262.       if(bytesread <= 0) {
  263.          return(-1);
  264.       } else {
  265.          CharsInCommBuff = bytesread;
  266.          CommBuffIdx = 0;
  267.       }
  268.    }
  269.    return(0xff & CommBuff[CommBuffIdx++]);
  270. }
  271.  
  272. #ifdef MAC
  273.  
  274. /*-- function write_wds --------------------------------------------------------
  275.  */
  276. write_wds(line,nchars)
  277. char *line;
  278. int nchars;
  279. {
  280.    char mesbuf[80];
  281.  
  282.       myWDS[0].length = nchars;
  283.       myWDS[0].ptr = line;
  284.       myWDS[1].length = 0;
  285.       myWDS[1].ptr = (Ptr) 0;
  286.  
  287.       TCPparamBlock.csCode = TCPSend;
  288.       TCPparamBlock.csParam.send.wdsPtr = (Ptr) &myWDS;
  289.       myOSErr = PBControl(&TCPparamBlock,FALSE);
  290.       if(myOSErr != noErr && !prevTCPError) {
  291.          sprintf(mesbuf,"TCPSend returned OSErr = %d.",myOSErr);
  292.          MessageBox(hWndConf,mesbuf,"Serious Communication error",MB_OK|MB_ICONHAND);
  293.          prevTCPError = TRUE;
  294.       }
  295. }
  296. #endif
  297.  
  298. /*-- function PutCommLine ----------------------------------------------
  299.  *
  300.  *  Output a line--either to a socket or to a serial port.
  301.  *
  302.  *  Entry   line   points to a buffer of characters.
  303.  *          nchars is the number of characters to output.
  304.  */
  305. void
  306. PutCommLine(line,nchars)
  307. char *line;
  308. unsigned int nchars;
  309. {
  310.    int retcode;
  311. #ifndef MAC
  312.    COMSTAT MyStat;
  313. #else
  314. #define MAXSENDLEN 256
  315.    char mybuf[MAXSENDLEN];
  316.    int j, mynchars;
  317.    char *cdest, *csource;
  318. #endif
  319.    char mesbuf[80];
  320.    BOOL Sent = FALSE;
  321.    long int lCount = nchars;
  322.  
  323.    if(UsingSocket) {
  324. #if 0
  325.       MessageBox(hWndConf,"About to net_write","in PutCommLine",MB_OK);
  326. #endif
  327. #ifndef MAC
  328. #ifdef USE_NET
  329.       net_write(NNTPSock,line,nchars,0);
  330.       net_write(NNTPSock,"\n",1,0);
  331. #else
  332.       inregs.h.ah = 0x1a;
  333.       inregs.x.bx = NNTPSock;
  334.       segregs.ds  = HIWORD((char far *)line);
  335.       inregs.x.si = LOWORD((char far *)line);
  336.       inregs.x.cx = nchars;
  337.       inregs.x.dx = 0;
  338.  
  339.       retcode = int86x(0x61,&inregs,&outregs,&segregs);
  340.  
  341.       mymesbuf[0] = '\n';
  342.       segregs.ds  = HIWORD((char far *)mymesbuf);
  343.       inregs.x.si = LOWORD((char far *)mymesbuf);
  344.       inregs.x.cx = 1;
  345.  
  346.       retcode = int86x(0x61,&inregs,&outregs,&segregs);
  347. #endif
  348.       if(DebugSock) {
  349.      MessageBox(hWndConf,"Just did net_write","in PutCommLine",MB_OK);
  350.       }
  351. #else
  352.       if(nchars >= MAXSENDLEN) {
  353.          sprintf(mesbuf,"nchars = %d",nchars);
  354.          MessageBox(hWndConf,"Line too long in PutCommLine",mesbuf,MB_OK);
  355.       }
  356.       for(cdest=mybuf, csource=line, mynchars=nchars; mynchars; mynchars--) {
  357.          *(cdest++) = *(csource++);
  358.       }
  359.       *(cdest++) = ' ';
  360.       *(cdest++) = '\n';
  361.       *cdest = '\0';
  362.       write_wds(mybuf,nchars+2);
  363. /*    write_wds(line,nchars);
  364.       write_wds("\n",1);*/
  365. /*    printf("Sent '%s', nchars=%d",mybuf,nchars); */
  366. #endif
  367.  
  368.    } else {
  369.       while (!Sent) {
  370. #ifndef MAC
  371.          GetCommError(CommDevice,&MyStat);
  372.          if(SERIALOUTBUFSIZE - MyStat.cbOutQue > nchars+1) {
  373.             WriteComm(CommDevice,line,nchars);
  374.             WriteComm(CommDevice,"\r",1);
  375.             Sent = TRUE;
  376.          } else {
  377.             MainLoopPass();
  378.          }
  379. #else
  380.          FSWrite(serialOut,&lCount,line);
  381.          lCount = 1;
  382.          FSWrite(serialOut,&lCount,"\r");
  383.          Sent = TRUE;
  384. #endif
  385.       }
  386.    }
  387. }
  388.  
  389. /*-- function MRRCloseComm -----------------------------------------
  390.  *
  391.  *  Close the communications port, serial or TCP.
  392.  */
  393. void
  394. MRRCloseComm()
  395. {
  396.    int timeout = 0;
  397.    int retcode;
  398.    char mesbuf[80];
  399.  
  400.    if(UsingSocket) {
  401. #ifndef MAC
  402. /*    setsockopt(NNTPSock,SOL_SOCKET,SO_LINGER,(char *)&timeout,2); */
  403.       PutCommLine("QUIT",4);
  404.  /*   close(NNTPSock); */
  405. #ifdef USE_NET
  406.       net_release(NNTPSock);
  407. #else
  408.       inregs.h.ah = 0x08;
  409.       inregs.x.bx = NNTPSock;
  410.  
  411.       retcode = int86x(0x61,&inregs,&outregs,&segregs);
  412. #endif
  413. #else
  414.       /* Close MacTCP socket */
  415.       TCPparamBlock.csCode = TCPRelease;
  416.       myOSErr = PBControl(&TCPparamBlock,FALSE);
  417.       if(myOSErr != noErr) {
  418.          sprintf(mesbuf,"TCPRelease returned OSErr = %d.",myOSErr);
  419.          MessageBox(hWndConf,mesbuf,"",MB_OK|MB_ICONHAND);
  420.       }
  421. #endif
  422.    } else {
  423. #ifndef MAC
  424.       CloseComm(CommDevice);
  425. #else
  426.       RAMSDClose(whichPort);
  427. #endif
  428.    }
  429. }
  430.  
  431. #ifdef MAC
  432. /*--- function ClearParamBlock -------------------------------------------
  433.  *
  434.  *    Zero out a parameter block for the PB (parameter block) routines on the Mac.
  435.  */
  436. void
  437. ClearParamBlock(paramBlock,nbytes)
  438. char *paramBlock;
  439. int  nbytes;
  440. {
  441.    int j=0;
  442.  
  443.    for(;j<nbytes;j++) paramBlock[j] = 0;
  444. }
  445. #endif
  446.  
  447. /*--- function MRRInitComm --------------------------------------------
  448.  *
  449.  *  Initialize communications--including figuring out whether
  450.  *  to use TCP or serial.
  451.  */
  452. int
  453. MRRInitComm()
  454. {
  455.    char mesbuf[80],mesbuf2[80],buf[80];
  456.    char szComName[10];
  457.    char *errptr;
  458.    int retcode, j;
  459. #ifdef MAC
  460.    long msuinfo = 0x23080214L;
  461.    long ebfs2 =   0x23080241L;
  462.    cntrlParam paramBlock;
  463. #endif
  464.  
  465. #ifdef TSRBUF
  466.    TCPaddr.structaddr.toff = INTBUFPTR;
  467.    TCPaddr.structaddr.tseg = 0;
  468.    CommBuff = *(TCPaddr.TCPpos);
  469. #endif
  470.  
  471. #ifndef MAC
  472. #else
  473.    UsingSocket = TRUE;
  474. #endif
  475.  
  476.    if(UsingSocket) {
  477.       IgnoreCommCh = '\r';
  478.       EOLCommCh = '\n';
  479.       retcode = SetupSock();
  480.       if(!retcode) {
  481.          MessageBox(hWndConf,"Can't set up socket","Initialization error",MB_OK|MB_ICONHAND);
  482.       }
  483. #ifdef MAC
  484.       /* Open the driver. */
  485.       ClearParamBlock(¶mBlock,sizeof(paramBlock));
  486.       paramBlock.ioNamePtr = (StringPtr) "\p.IPP";
  487. /*    paramBlock.ioPermssn = fsRdWrShPerm; */
  488.       myOSErr = PBOpen(¶mBlock,FALSE);
  489.       if(myOSErr != noErr) {
  490.          sprintf(mesbuf,"PBOpen returned OSErr = %d.",myOSErr);
  491.          MessageBox(hWndConf,mesbuf,"",MB_OK|MB_ICONHAND);
  492.          prevTCPError = TRUE;
  493.       }
  494.       SockRefNum = paramBlock.ioRefNum;
  495.  
  496.       /* Create the socket. */
  497.       ClearParamBlock(&TCPparamBlock,sizeof(TCPparamBlock));
  498.       TCPparamBlock.ioCRefNum = SockRefNum;
  499.       TCPparamBlock.csCode = TCPCreate;
  500.       SerBufSize = TCPBUFSIZE;
  501.       hSerBuf = NewHandle(SerBufSize);
  502.       HLock(hSerBuf);
  503.       lpSerBuf = *hSerBuf;
  504.       TCPparamBlock.csParam.create.rcvBuff = (Ptr) lpSerBuf;
  505.       TCPparamBlock.csParam.create.rcvBuffLen = TCPBUFSIZE;
  506.       myOSErr = PBControl(&TCPparamBlock,FALSE);
  507.  
  508.       if(myOSErr != noErr) {
  509.          sprintf(mesbuf,"TCPCreate returned OSErr = %d.",myOSErr);
  510.          MessageBox(hWndConf,mesbuf,"",MB_OK|MB_ICONHAND);
  511.       }
  512.       NNTPSock = TCPparamBlock.tcpStream;
  513.  
  514.       /* Open the connection to the server. */
  515.  
  516.       TCPparamBlock.csCode = TCPActiveOpen;
  517.       TCPparamBlock.csParam.open.remoteHost = (ip_addr) msuinfo; /* msuinfo */
  518.       TCPparamBlock.csParam.open.remotePort = 119 /* 1041 */ ;
  519.       myOSErr = PBControl(&TCPparamBlock,FALSE);
  520.       if(myOSErr != noErr) {
  521.          sprintf(mesbuf,"TCPActiveOpen returned OSErr = %d.",myOSErr);
  522.          MessageBox(hWndConf,mesbuf,"",MB_OK|MB_ICONHAND);
  523.       }
  524.  
  525.       /* Start the first read on the socket. */
  526.  
  527.       TCPReadparamBlock = TCPparamBlock;
  528.  
  529.       TCPReadparamBlock.csCode = TCPRcv;
  530. /*    TCPReadparamBlock.csParam.receive.commandTimeoutValue = 1; */
  531.       TCPReadparamBlock.csParam.receive.rcvBuff = CommBuff;
  532.       TCPReadparamBlock.csParam.receive.rcvBuffLen = COMMBUFSIZE;
  533.       myOSErr = PBControl(&TCPReadparamBlock,TRUE);
  534.       if(myOSErr != noErr &&  myOSErr != commandTimeout) {
  535.          sprintf(mesbuf,"TCPRcv ret %d",myOSErr);
  536.          MessageBox(hWndConf,mesbuf,"",MB_OK|MB_ICONHAND);
  537.       }
  538. #endif
  539.    } else {
  540.       IgnoreCommCh = '\r';
  541.       EOLCommCh = '\n';      /* Used to be reversed */
  542.  
  543.       /* Set up Comm parameters.                                        */
  544.  
  545. #ifndef MAC
  546.  
  547.       /*
  548.        *  Open the Comm port.  I use a hard-coded communications rate
  549.        *  and other parameters; obviously, this should be improved
  550.        *  with a config file.
  551.        */
  552.  
  553.       strncpy(szComName,szCommString,4);
  554.       szComName[4] = '\0';
  555.       CommDevice = OpenComm(szComName,4096,SERIALOUTBUFSIZE);
  556.       if(CommDevice < 0) {
  557.          sprintf(mesbuf,"OpenComm returned %d",CommDevice);
  558.          strcpy(mesbuf2,"Error opening '");
  559.          strcat(mesbuf2,szComName);
  560.          strcat(mesbuf2,"'");
  561.          MessageBox(hWndConf,mesbuf,mesbuf2,MB_OK|MB_ICONEXCLAMATION);
  562.       } else {
  563.           WinVnDoComm(szCommString);
  564.       }
  565. #else
  566.       RAMSDOpen(whichPort);
  567.       SerReset(serialIn,serConfig);
  568.  
  569.       hSerBuf = NewHandle(SerBufSize);
  570.       HLock(hSerBuf);
  571.       lpSerBuf = *hSerBuf;
  572.       SerSetBuf(serialIn,lpSerBuf,(int)SerBufSize);
  573.  
  574. #endif
  575.    }
  576.  
  577.    /* Put out an illegal command, just so we can watch the           */
  578.    /* server come back with an "Unrecognized command" message.       */
  579.    /* This ensures that the comm link is up and we're talking to NNTP*/
  580.  
  581.    CommLinePtr = CommLineIn;
  582.    PutCommLine("Patty",5);
  583.    CommState = ST_ESTABLISH_COMM;
  584.    CommBusy = TRUE;
  585.    return(0);
  586. }
  587.